`:top
In software systems, `!encapsulation`! refers to the bundling of data with the mechanisms or methods that operate on the data. It may also refer to the limiting of direct access to some of that data, such as an object's components.`:cite-ref-rogers01-1-0[`F5bf`_`[1`#cite-note-rogers01-1]`_`f] Essentially, encapsulation prevents external code from being concerned with the internal workings of an object.
Encapsulation allows developers to present a consistent interface that is independent of its internal implementation. As one example, encapsulation can be used to hide the values or state of a structured data object inside a `F33f`_`[class`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Class_(computer_programming)]`_`f. This prevents clients from directly accessing this information in a way that could expose hidden implementation details or violate `F33f`_`[state`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=State_(computer_science)]`_`f invariance maintained by the methods.
Encapsulation also encourages programmers to put all the code that is concerned with a certain set of data in the same class, which organizes it for easy comprehension by other programmers. Encapsulation is a technique that encourages `F33f`_`[decoupling`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Coupling_(computer_programming)]`_`f.
All `F33f`_`[object-oriented programming`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object-oriented_programming]`_`f (OOP) systems support encapsulation,`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f]`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f] but encapsulation is not unique to OOP. Implementations of `F33f`_`[abstract data types`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Abstract_data_types]`_`f, `F33f`_`[modules`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Module_(programming)]`_`f, and `F33f`_`[libraries`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Library_(computing)]`_`f also offer encapsulation. The similarity has been explained by programming language theorists in terms of `F33f`_`[existential types`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Existential_types]`_`f.`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]
>>Contents
• `F0af`_`[Meaning`#meaning]`_`f
• `F0af`_`[Encapsulation and inheritance`#encapsulation-and-inheritance]`_`f
• `F0af`_`[Information hiding`#information-hiding]`_`f
• `F0af`_`[Examples`#examples]`_`f
• `F0af`_`[See also`#see-also]`_`f
• `F0af`_`[Citations`#citations]`_`f
• `F0af`_`[References`#references]`_`f
-─
>>Meaning
In `F33f`_`[object-oriented programming languages`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object-oriented_programming_languages]`_`f, and other related fields, encapsulation refers to one of two related but distinct notions, and sometimes to the combination thereof:`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f]`:cite-ref-dale-6-0[`F5bf`_`[6`#cite-note-dale-6]`_`f]
• A language mechanism for restricting direct access to some of the `F33f`_`[object`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object_(computer_science)]`_`f's components.`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]`:cite-ref-pierce-8-0[`F5bf`_`[8`#cite-note-pierce-8]`_`f]
• A language construct that facilitates the bundling of data with the `F33f`_`[methods`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Method_(computer_programming)]`_`f (or other functions) operating on those data.`:cite-ref-rogers01-1-1[`F5bf`_`[1`#cite-note-rogers01-1]`_`f]`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f]
Some programming language researchers and academics use the first meaning alone or in combination with the second as a distinguishing feature of `F33f`_`[object-oriented programming`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object-oriented_programming]`_`f, while some programming languages that provide `F33f`_`[lexical closures`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Closure_(computer_programming)]`_`f view encapsulation as a feature of the language `F33f`_`[orthogonal`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Orthogonality]`_`f to object orientation.
The second definition reflects that in many object-oriented languages, and other related fields, the components are not hidden automatically and this can be overridden. Thus, `F33f`_`[information hiding`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Information_hiding]`_`f is defined as a separate notion by those who prefer the second definition.
The features of encapsulation are supported using `F33f`_`[classes`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Class_(computer_programming)]`_`f in most object-oriented languages, although other alternatives also exist.
Encapsulation may also refer to containing a repetitive or complex process in a single unit to be invoked. Object-oriented programming facilitate this at both the method and class levels. This definition is also applicable to `F33f`_`[procedural programming`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Procedural_programming]`_`f.`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f]
>>>Encapsulation and inheritance
The authors of `*`F33f`_`[Design Patterns`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Design_Patterns]`_`f`* discuss the tension between `F33f`_`[inheritance`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Inheritance_(object-oriented_programming)]`_`f and encapsulation at length and state that in their experience, designers overuse inheritance. They claim that inheritance often breaks encapsulation, given that inheritance exposes a subclass to the details of its parent's implementation.`:cite-ref-gof-11-0[`F5bf`_`[11`#cite-note-gof-11]`_`f] As described by the `F33f`_`[yo-yo problem`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Yo-yo_problem]`_`f, overuse of inheritance and therefore encapsulation, can become too complicated and hard to debug.
>>Information hiding
Under the definition that encapsulation "can be used to hide data members and member functions", the internal representation of an `F33f`_`[object`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object_(computer_science)]`_`f is generally hidden outside of the object's definition. Typically, only the object's own methods can directly inspect or manipulate its fields. Hiding the internals of the object protects its integrity by preventing users from setting the internal data of the component into an invalid or inconsistent state. A supposed benefit of encapsulation is that it can reduce system complexity, and thus increase `F33f`_`[robustness`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Robustness_(computer_science)]`_`f, by allowing the developer to limit the interdependencies between software components.
Some languages like `F33f`_`[Smalltalk`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Smalltalk]`_`f and `F33f`_`[Ruby`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Ruby_(programming_language)]`_`f only allow access via object methods, but most others (e.g., `F33f`_`[C++`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C++]`_`f, `F33f`_`[C#`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C_Sharp_(programming_language)]`_`f, `F33f`_`[Delphi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Delphi_(programming_language)]`_`f or `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_(programming_language)]`_`f`:cite-ref-footnotebloch201873-77chapter-4-item-15-minimize-the-accessibility-of-classes-and-members-12-0[`F5bf`_`[12`#cite-note-footnotebloch201873-77chapter-4-item-15-minimize-the-accessibility-of-classes-and-members-12]`_`f]) offer the programmer some control over what is hidden, typically via keywords like `B100`F9d9public`f`b and `B100`F9d9private`f`b.`:cite-ref-pierce-8-1[`F5bf`_`[8`#cite-note-pierce-8]`_`f] ISO C++ standard refers to `B100`F9d9protected`f`b, `B100`F9d9private`f`b and `B100`F9d9public`f`b as "`F33f`_`[access specifiers`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Access_specifiers]`_`f" and that they do not "hide any information". Information hiding is accomplished by furnishing a compiled version of the source code that is interfaced via a header file.
Almost always, there is a way to override such protection – usually via `F33f`_`[reflection`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Reflection_(computer_programming)]`_`f API (Ruby, Java, C#, etc.), sometimes by mechanism like `F33f`_`[name mangling`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Name_mangling]`_`f (`F33f`_`[Python`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Python_(programming_language)]`_`f), or special keyword usage like `B100`F9d9friend`f`b in C++. Systems that provide object-level `F33f`_`[capability-based security`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Capability-based_security]`_`f (adhering to the `F33f`_`[object-capability model`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object-capability_model]`_`f) are an exception, and guarantee strong encapsulation.
>>>Examples
>>>>Restricting data fields
Languages like `F33f`_`[C++`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C++]`_`f, `F33f`_`[C#`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C_Sharp_(programming_language)]`_`f, `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_(programming_language)]`_`f,`:cite-ref-footnotebloch201873-77chapter-4-item-15-minimize-the-accessibility-of-classes-and-members-12-1[`F5bf`_`[12`#cite-note-footnotebloch201873-77chapter-4-item-15-minimize-the-accessibility-of-classes-and-members-12]`_`f] `F33f`_`[PHP`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=PHP]`_`f, `F33f`_`[Swift`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Swift_(programming_language)]`_`f, and `F33f`_`[Delphi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Delphi_(programming_language)]`_`f offer ways to restrict access to data fields.
Below is an example in `F33f`_`[C#`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C_Sharp_(programming_language)]`_`f that shows how access to a data field can be restricted through the use of a `B100`F9d9private`f`b keyword:
`B100`F9d9class Program`f`b
`B100`F9d9{`f`b
`B100`F9d9 public class Account`f`b
`B100`F9d9 {`f`b
`B100`F9d9 private decimal _accountBalance = 500.00m;`f`b
`B100`F9d9`f`b
`B100`F9d9 public decimal CheckBalance()`f`b
`B100`F9d9 {`f`b
`B100`F9d9 return _accountBalance;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 static void Main()`f`b
`B100`F9d9 {`f`b
`B100`F9d9 Account myAccount = new Account();`f`b
`B100`F9d9 decimal myBalance = myAccount.CheckBalance();`f`b
`B100`F9d9`f`b
`B100`F9d9 /* This Main method can check the balance via the public`f`b
`B100`F9d9 * "CheckBalance" method provided by the "Account" class`f`b
`B100`F9d9 * but it cannot manipulate the value of "accountBalance" */`f`b
`B100`F9d9 }`f`b
`B100`F9d9}`f`b
Below is an example in `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Java_(programming_language)]`_`f:
`B100`F9d9public class Employee {`f`b
`B100`F9d9 private BigDecimal salary = new BigDecimal(50000.00);`f`b
`B100`F9d9`f`b
`B100`F9d9 public BigDecimal getSalary() {`f`b
`B100`F9d9 return this.salary;`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 public static void main() {`f`b
`B100`F9d9 Employee e = new Employee();`f`b
`B100`F9d9 BigDecimal sal = e.getSalary();`f`b
`B100`F9d9 }`f`b
`B100`F9d9}`f`b
Encapsulation is also possible in non-object-oriented languages. In `F33f`_`[C`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=C_(programming_language)]`_`f, for example, a structure can be declared in the public API via the header file for a set of functions that operate on an item of data containing data members that are not accessible to clients of the API with the `B100`F9d9extern`f`b keyword.`:cite-ref-13[`F5bf`_`[13`#cite-note-13]`_`f]
`B100`F9d9// Header file "api.h"`f`b
`B100`F9d9`f`b
`B100`F9d9struct Entity; // Opaque structure with hidden members`f`b
`B100`F9d9`f`b
`B100`F9d9// API functions that operate on 'Entity' objects`f`b
`B100`F9d9extern struct Entity * open_entity(int id);`f`b
`B100`F9d9extern int process_entity(struct Entity *info);`f`b
`B100`F9d9extern void close_entity(struct Entity *info);`f`b
`B100`F9d9// extern keywords here are redundant, but don't hurt.`f`b
`B100`F9d9// extern defines functions that can be called outside the current file, the default behavior even without the keyword`f`b
Clients call the API functions to allocate, operate on, and deallocate objects of an `F33f`_`[opaque data type`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Opaque_data_type]`_`f. The contents of this type are known and accessible only to the implementation of the API functions; clients cannot directly access its contents. The source code for these functions defines the actual contents of the structure:
`B100`F9d9// Implementation file "api.c"`f`b
`B100`F9d9`f`b
`B100`F9d9#include "api.h"`f`b
`B100`F9d9`f`b
`B100`F9d9struct Entity {`f`b
`B100`F9d9 int ent_id; // ID number`f`b
`B100`F9d9 char ent_name[20]; // Name`f`b
`B100`F9d9 ... and other members ...`f`b
`B100`F9d9};`f`b
`B100`F9d9`f`b
`B100`F9d9// API function implementations`f`b
`B100`F9d9struct Entity * open_entity(int id)`f`b
`B100`F9d9{ ... }`f`b
`B100`F9d9`f`b
`B100`F9d9int process_entity(struct Entity *info)`f`b
`B100`F9d9{ ... }`f`b
`B100`F9d9`f`b
`B100`F9d9void close_entity(struct Entity *info)`f`b
`B100`F9d9{ ... }`f`b
>>>>Name mangling
Below is an example of `F33f`_`[Python`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Python_(programming_language)]`_`f, which does not support variable access restrictions. However, the convention is that a variable whose name is prefixed by an underscore should be considered private.`:cite-ref-14[`F5bf`_`[14`#cite-note-14]`_`f]
`B100`F9d9class Car:`f`b
`B100`F9d9 def __init__(self) -> None:`f`b
`B100`F9d9 self._maxspeed = 200`f`b
`B100`F9d9`f`b
`B100`F9d9 def drive(self) -> None:`f`b
`B100`F9d9 print(f"Maximum speed is {self._maxspeed}.")`f`b
`B100`F9d9`f`b
`B100`F9d9redcar = Car()`f`b
`B100`F9d9redcar.drive() # This will print 'Maximum speed is 200.'`f`b
`B100`F9d9`f`b
`B100`F9d9redcar._maxspeed = 10`f`b
`B100`F9d9redcar.drive() # This will print 'Maximum speed is 10.'`f`b
>>See also
• `F33f`_`[Inheritance (object-oriented programming)`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Inheritance_(object-oriented_programming)]`_`f
• `F33f`_`[Object-oriented programming`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Object-oriented_programming]`_`f
• `F33f`_`[Software design pattern`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Software_design_pattern]`_`f
• `F33f`_`[Facade pattern`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Facade_pattern]`_`f
>>Citations
`:cite-note-rogers01-1`!1.`! `F0af`_`[↑`#cite-ref-rogers01-1-0]`_`f `:citerefrogers2001`aRogers, Wm. Paul (18 May 2001). "Encapsulation is not information hiding". `*`F33f`_`[JavaWorld`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=JavaWorld]`_`f`*. Retrieved 2020-07-20.
`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f "What is Object-Oriented Programming (OOP)?". `*App Architecture`*. Retrieved 2024-03-02.
`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f "Encapsulation in Object Oriented Programming (OOPS)". `*www.enjoyalgorithms.com`*. Retrieved 2024-03-02.
`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f `F33f`_`[Pierce 2002`#citerefpierce2002]`_`f, § 24.2 Data Abstraction with Existentials
`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f `:citerefscott2006`aScott, Michael Lee (2006). `*Programming language pragmatics`* (2 ed.). Morgan Kaufmann. p. 481. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0-12-633951-2. Encapsulation mechanisms enable the programmer to group data and the subroutines that operate on them together in one place, and to hide irrelevant details from the users of an abstraction
`:cite-note-dale-6`!6.`! `F0af`_`[↑`#cite-ref-dale-6-0]`_`f `:citerefdaleweems2007`aDale, Nell B.; Weems, Chip (2007). `*Programming and problem solving with Java`* (2nd ed.). Jones & Bartlett. p. 396. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0-7637-3402-2.
`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f `:citerefmitchell2003`a`F33f`_`[Mitchell, John C.`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=John_C._Mitchell]`_`f (2003). `*Concepts in programming languages`*. Cambridge University Press. p. 522. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0-521-78098-8.
`:cite-note-pierce-8`!8.`! `F0af`_`[↑`#cite-ref-pierce-8-0]`_`f `:citerefpierce2002`a`F33f`_`[Pierce, Benjamin`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Benjamin_C._Pierce]`_`f (2002). `F33f`_`[Types and Programming Languages`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Types_and_Programming_Languages]`_`f. MIT Press. p. 266. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0-262-16209-8.
`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f `:citerefconnollybegg2005`aConnolly, Thomas M.; Begg, Carolyn E. (2005). "Ch. 25: Introduction to Object DMBS § Object-oriented concepts". `*Database systems: a practical approach to design, implementation, and management`* (4th ed.). Pearson Education. p. 814. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0-321-21025-8.
`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f `:citerefmcdonough2017`aMcDonough, James E. (2017). "Encapsulation". `*Object-Oriented Design with ABAP: A Practical Approach`*. `F33f`_`[Apress`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Apress]`_`f. `F33f`_`[doi`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=Doi_(identifier)]`_`f:10.1007/978-1-4842-2838-8. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-1-4842-2837-1 – via `F33f`_`[O'Reilly`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=O'Reilly_Media]`_`f.
`:cite-note-gof-11`!11.`! `F0af`_`[↑`#cite-ref-gof-11-0]`_`f `:citerefgammahelmjohnsonvlissides1994`aGamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1994). `*Design Patterns`*. Addison-Wesley. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0-201-63361-0.
`:cite-note-footnotebloch201873-77chapter-4-item-15-minimize-the-accessibility-of-classes-and-members-12`!12.`! `F0af`_`[↑`#cite-ref-footnotebloch201873-77chapter-4-item-15-minimize-the-accessibility-of-classes-and-members-12-0]`_`f `F33f`_`[Bloch 2018`#citerefbloch2018]`_`f, pp. 73–77, Chapter §4 Item 15 Minimize the accessibility of classes and members.
`:cite-note-13`!13.`! `F0af`_`[↑`#cite-ref-13]`_`f `:citerefking2008`aKing, K. N. (2008). `*C Programming: A Modern Approach`* (2nd ed.). W. W. Norton & Company. p. 464. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0393979503.
`:cite-note-14`!14.`! `F0af`_`[↑`#cite-ref-14]`_`f `:citerefbader`aBader, Dan. "The Meaning of Underscores in Python". `*Improve Your Python Skills`*. Retrieved 1 November 2019.
>>References
• `:citerefbloch2018`aBloch, Joshua (2018). `*"Effective Java: Programming Language Guide"`* (third ed.). Addison-Wesley. `F33f`_`[ISBN`:/page/wikibook/entry.mu`zim=wikipedia_en_all_nopic_2025-08.zim|entry_path=ISBN_(identifier)]`_`f 978-0134685991.
`c`F0af`_`[↑ Back to top`#top]`_`f`a